import type { KnowledgeDetail } from '@/types/knowledge';

/**
 * 面向对象知识点数据
 */
export const oopKnowledge : KnowledgeDetail[] = [
	{
		id: 6,
		title: '类与对象',
		description: '理解类与对象的关系，掌握对象的创建、属性访问和方法调用，是面向对象编程的基础。',
		icon: '🏷️',
		categoryId: 'oop',
		categoryName: '面向对象编程',
		categoryIcon: '🎯',
		difficulty: '重要',
		color: 'linear-gradient(135deg, #fa709a 0%, #fee140 100%)',
		headerBg: 'linear-gradient(135deg, #2c3e50 0%, #34495e 100%)',
		tagBg: 'linear-gradient(135deg, #e74c3c 0%, #c0392b 100%)',
		tagColor: '#ffffff',
		difficultyBg: 'linear-gradient(135deg, #f39c12 0%, #e67e22 100%)',
		keyPoints: [
			{
				point: '类是对象的模板或蓝图，对象是类的实例。类定义了对象的属性（成员变量）和行为（方法）。',
				code: `// 定义一个Person类
public class Person {
    // 成员变量（属性）
    private String name;
    private int age;
    private String gender;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 成员方法（行为）
    public void introduce() {
        System.out.println("我叫" + name + "，今年" + age + "岁");
    }
    
    // getter和setter方法
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}`
			},
			{
				point: '使用new关键字创建对象，会在堆内存中分配空间，并调用构造方法初始化对象。',
				code: `public class ObjectCreation {
    public static void main(String[] args) {
        // 创建对象
        Person person1 = new Person("张三", 25);
        Person person2 = new Person("李四", 30);
        
        // 访问对象的方法
        person1.introduce();  // 我叫张三，今年25岁
        person2.introduce();  // 我叫李四，今年30岁
        
        // 对象引用
        Person person3 = person1;  // person3和person1指向同一个对象
        person3.setName("王五");
        person1.introduce();  // 我叫王五，今年25岁
        
        // null引用
        Person person4 = null;
        // person4.introduce();  // NullPointerException
    }
}`
			},
			{
				point: 'this关键字代表当前对象的引用，用于区分成员变量和局部变量，或在构造方法中调用其他构造方法。',
				code: `public class Student {
    private String name;
    private int age;
    private String className;
    
    // 使用this区分成员变量和参数
    public Student(String name, int age) {
        this.name = name;  // this.name是成员变量，name是参数
        this.age = age;
    }
    
    // 构造方法重载，使用this调用其他构造方法
    public Student(String name, int age, String className) {
        this(name, age);  // 调用两参数的构造方法
        this.className = className;
    }
    
    // 返回当前对象
    public Student setName(String name) {
        this.name = name;
        return this;  // 支持链式调用
    }
    
    public Student setAge(int age) {
        this.age = age;
        return this;
    }
}`
			},
			{
				point: '对象在内存中的存储：引用变量存储在栈中，对象实例存储在堆中，引用变量保存对象的地址。',
				code: `public class MemoryDemo {
    public static void main(String[] args) {
        // person1是栈中的引用变量，指向堆中的Person对象
        Person person1 = new Person("张三", 25);
        
        // person2是另一个引用变量，指向新的Person对象
        Person person2 = new Person("李四", 30);
        
        // 引用传递
        Person person3 = person1;  // person3和person1指向同一对象
        
        // 修改person3会影响person1（因为指向同一对象）
        person3.setName("王五");
        System.out.println(person1.getName());  // 王五
        
        // 重新赋值不影响原对象
        person1 = new Person("赵六", 35);
        System.out.println(person3.getName());  // 王五（不受影响）
    }
}`
			},
			{
				point: '封装要求将对象的属性私有化，通过公共方法访问，可以隐藏实现细节并进行数据验证。',
				code: `public class BankAccount {
    // 私有属性，外部无法直接访问
    private String accountNumber;
    private double balance;
    private String password;
    
    public BankAccount(String accountNumber, String password) {
        this.accountNumber = accountNumber;
        this.password = password;
        this.balance = 0.0;
    }
    
    // 存款方法（数据验证）
    public boolean deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            return true;
        }
        return false;
    }
    
    // 取款方法（权限检查和数据验证）
    public boolean withdraw(String pwd, double amount) {
        if (!password.equals(pwd)) {
            System.out.println("密码错误");
            return false;
        }
        if (amount > balance) {
            System.out.println("余额不足");
            return false;
        }
        balance -= amount;
        return true;
    }
    
    // 查询余额（只读访问）
    public double getBalance(String pwd) {
        return password.equals(pwd) ? balance : -1;
    }
}`
			}
		]
	},
	{
		id: 7,
		title: '继承',
		description: '继承是面向对象三大特性之一，允许子类继承父类的属性和方法，实现代码复用和扩展。',
		icon: '👨‍👦',
		categoryId: 'oop',
		categoryName: '面向对象编程',
		categoryIcon: '🎯',
		difficulty: '重要',
		color: 'linear-gradient(135deg, #fa709a 0%, #fee140 100%)',
		headerBg: 'linear-gradient(135deg, #2c3e50 0%, #34495e 100%)',
		tagBg: 'linear-gradient(135deg, #e74c3c 0%, #c0392b 100%)',
		tagColor: '#ffffff',
		difficultyBg: 'linear-gradient(135deg, #f39c12 0%, #e67e22 100%)',
		keyPoints: [
			{
				point: '使用extends关键字实现继承，子类继承父类的非私有属性和方法，Java只支持单继承。',
				code: `// 父类
public class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void eat() {
        System.out.println(name + "正在吃东西");
    }
}

// 子类继承父类
public class Dog extends Animal {
    private String breed;  // 子类特有属性
    
    public Dog(String name, int age, String breed) {
        super(name, age);  // 调用父类构造方法
        this.breed = breed;
    }
    
    // 子类特有方法
    public void bark() {
        System.out.println(name + "正在汪汪叫");
    }
}`
			},
			{
				point: 'super关键字用于访问父类的成员，包括调用父类构造方法、访问父类方法和属性。',
				code: `public class Parent {
    protected String name = "父类";
    
    public Parent() {
        System.out.println("父类无参构造");
    }
    
    public Parent(String name) {
        this.name = name;
        System.out.println("父类有参构造: " + name);
    }
    
    public void show() {
        System.out.println("父类方法");
    }
}

public class Child extends Parent {
    private String name = "子类";
    
    public Child() {
        super("调用父类构造");  // 必须在第一行
        System.out.println("子类构造");
    }
    
    public void display() {
        System.out.println(this.name);      // 子类
        System.out.println(super.name);     // 父类
        super.show();                        // 调用父类方法
    }
}`
			},
			{
				point: '方法重写(Override)允许子类提供父类方法的新实现，遵循"两同两小一大"原则。',
				code: `public class Shape {
    public double getArea() {
        return 0;
    }
    
    public void draw() {
        System.out.println("绘制图形");
    }
}

public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    // 重写父类方法
    @Override  // 注解，帮助编译器检查
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public void draw() {
        super.draw();  // 可以调用父类方法
        System.out.println("绘制圆形，半径: " + radius);
    }
}

// 测试
Circle circle = new Circle(5);
System.out.println(circle.getArea());  // 78.54...
circle.draw();`
			},
			{
				point: 'final关键字可以修饰类、方法、变量，被final修饰的类不能被继承，方法不能被重写，变量不能被修改。',
				code: `// final类，不能被继承
public final class ImmutableClass {
    private final String value;
    
    public ImmutableClass(String value) {
        this.value = value;
    }
}

// class SubClass extends ImmutableClass { }  // 编译错误

public class Parent {
    // final方法，不能被重写
    public final void finalMethod() {
        System.out.println("不能被重写");
    }
    
    public void normalMethod() {
        // final变量，不能被修改
        final int MAX_SIZE = 100;
        // MAX_SIZE = 200;  // 编译错误
    }
}

public class Child extends Parent {
    // @Override
    // public void finalMethod() { }  // 编译错误
}`
			},
			{
				point: '多态性允许父类引用指向子类对象，运行时动态绑定调用子类的重写方法，是面向对象的核心特性。',
				code: `public class PolymorphismDemo {
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Animal animal1 = new Dog("旺财", 3, "金毛");
        Animal animal2 = new Cat("咪咪", 2, "橘猫");
        
        // 调用重写的方法（动态绑定）
        animal1.makeSound();  // 汪汪叫
        animal2.makeSound();  // 喵喵叫
        
        // 使用多态实现通用方法
        feed(animal1);  // 喂养旺财
        feed(animal2);  // 喂养咪咪
        
        // 向下转型（需要判断类型）
        if (animal1 instanceof Dog) {
            Dog dog = (Dog) animal1;
            dog.bark();  // 调用子类特有方法
        }
    }
    
    // 通用方法，接受父类类型参数
    public static void feed(Animal animal) {
        System.out.println("喂养" + animal.getName());
        animal.eat();
    }
}`
			}
		]
	},
	{
		id: 8,
		title: '抽象类与接口',
		description: '抽象类和接口用于定义规范，是实现多态和解耦的重要工具，理解它们的区别和使用场景。',
		icon: '📐',
		categoryId: 'oop',
		categoryName: '面向对象编程',
		categoryIcon: '🎯',
		difficulty: '重要',
		color: 'linear-gradient(135deg, #fa709a 0%, #fee140 100%)',
		headerBg: 'linear-gradient(135deg, #2c3e50 0%, #34495e 100%)',
		tagBg: 'linear-gradient(135deg, #e74c3c 0%, #c0392b 100%)',
		tagColor: '#ffffff',
		difficultyBg: 'linear-gradient(135deg, #f39c12 0%, #e67e22 100%)',
		keyPoints: [
			{
				point: '抽象类使用abstract关键字，可以包含抽象方法和具体方法，不能实例化，用于定义模板。',
				code: `// 抽象类
public abstract class Vehicle {
    protected String brand;
    protected int speed;
    
    // 构造方法
    public Vehicle(String brand) {
        this.brand = brand;
    }
    
    // 抽象方法（没有方法体）
    public abstract void start();
    public abstract void stop();
    
    // 具体方法
    public void accelerate(int increment) {
        speed += increment;
        System.out.println("加速到 " + speed + " km/h");
    }
}

// 子类必须实现所有抽象方法
public class Car extends Vehicle {
    public Car(String brand) {
        super(brand);
    }
    
    @Override
    public void start() {
        System.out.println(brand + " 汽车启动");
    }
    
    @Override
    public void stop() {
        System.out.println(brand + " 汽车停止");
        speed = 0;
    }
}`
			},
			{
				point: '接口使用interface关键字，所有方法默认是public abstract，Java 8+支持默认方法和静态方法。',
				code: `// 接口定义
public interface Flyable {
    // 常量（默认public static final）
    int MAX_HEIGHT = 10000;
    
    // 抽象方法（默认public abstract）
    void fly();
    void land();
    
    // 默认方法（Java 8+）
    default void takeOff() {
        System.out.println("起飞中...");
        fly();
    }
    
    // 静态方法（Java 8+）
    static void checkWeather() {
        System.out.println("检查天气状况");
    }
}

// 实现接口
public class Airplane implements Flyable {
    @Override
    public void fly() {
        System.out.println("飞机在飞行");
    }
    
    @Override
    public void land() {
        System.out.println("飞机降落");
    }
}`
			},
			{
				point: '一个类可以实现多个接口，实现多继承的效果，接口之间也可以继承。',
				code: `// 多个接口
public interface Swimmable {
    void swim();
}

public interface Walkable {
    void walk();
}

// 实现多个接口
public class Duck implements Flyable, Swimmable, Walkable {
    @Override
    public void fly() {
        System.out.println("鸭子在飞");
    }
    
    @Override
    public void land() {
        System.out.println("鸭子降落");
    }
    
    @Override
    public void swim() {
        System.out.println("鸭子在游泳");
    }
    
    @Override
    public void walk() {
        System.out.println("鸭子在走路");
    }
}

// 接口继承接口
public interface SuperAnimal extends Flyable, Swimmable {
    void eat();
}`
			},
			{
				point: '抽象类用于代码复用和定义模板，接口用于定义规范和实现多继承，选择依据实际需求。',
				code: `// 抽象类：描述"是什么"（is-a关系）
public abstract class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    // 共同行为的具体实现
    public void sleep() {
        System.out.println(name + "在睡觉");
    }
    
    // 不同实现的抽象方法
    public abstract void makeSound();
}

// 接口：描述"能做什么"（能力）
public interface Runnable {
    void run();
}

// 组合使用
public class Dog extends Animal implements Runnable {
    public Dog(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + "汪汪叫");
    }
    
    @Override
    public void run() {
        System.out.println(name + "在奔跑");
    }
}`
			},
			{
				point: 'Java 8+接口可以有默认方法和静态方法，Java 9+支持私有方法，增强了接口的功能。',
				code: `public interface ModernInterface {
    // 抽象方法
    void abstractMethod();
    
    // 默认方法
    default void defaultMethod() {
        System.out.println("默认实现");
        privateMethod();  // 可以调用私有方法
    }
    
    // 静态方法
    static void staticMethod() {
        System.out.println("静态方法");
        privateStaticMethod();
    }
    
    // 私有方法（Java 9+）
    private void privateMethod() {
        System.out.println("私有方法");
    }
    
    // 私有静态方法（Java 9+）
    private static void privateStaticMethod() {
        System.out.println("私有静态方法");
    }
}

// 实现类
public class Implementation implements ModernInterface {
    @Override
    public void abstractMethod() {
        System.out.println("实现抽象方法");
    }
    
    // 可以选择重写默认方法
    @Override
    public void defaultMethod() {
        System.out.println("重写默认方法");
    }
}`
			}
		]
	},
	{
		id: 9,
		title: '内部类',
		description: '内部类是定义在另一个类中的类，包括成员内部类、静态内部类、局部内部类和匿名内部类。',
		icon: '🎭',
		categoryId: 'oop',
		categoryName: '面向对象编程',
		categoryIcon: '🎯',
		difficulty: '进阶',
		color: 'linear-gradient(135deg, #fa709a 0%, #fee140 100%)',
		headerBg: 'linear-gradient(135deg, #2c3e50 0%, #34495e 100%)',
		tagBg: 'linear-gradient(135deg, #e74c3c 0%, #c0392b 100%)',
		tagColor: '#ffffff',
		difficultyBg: 'linear-gradient(135deg, #e74c3c 0%, #c0392b 100%)',
		keyPoints: [
			{
				point: '成员内部类可以访问外部类的所有成员，需要通过外部类实例创建内部类对象。',
				code: `public class Outer {
    private String outerField = "外部类属性";
    private static String staticField = "静态属性";
    
    // 成员内部类
    public class Inner {
        private String innerField = "内部类属性";
        
        public void display() {
            // 可以访问外部类的所有成员
            System.out.println(outerField);
            System.out.println(staticField);
            System.out.println(Outer.this.outerField);  // 明确引用
        }
    }
    
    public void test() {
        // 外部类可以访问内部类
        Inner inner = new Inner();
        inner.display();
    }
}

// 外部创建内部类对象
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.display();`
			},
			{
				point: '静态内部类使用static修饰，不依赖外部类实例，只能访问外部类的静态成员。',
				code: `public class Outer {
    private static String staticField = "静态属性";
    private String instanceField = "实例属性";
    
    // 静态内部类
    public static class StaticInner {
        private String field = "静态内部类";
        
        public void display() {
            // 可以访问外部类的静态成员
            System.out.println(staticField);
            // System.out.println(instanceField);  // 错误！
        }
        
        public static void staticMethod() {
            System.out.println("静态内部类的静态方法");
        }
    }
}

// 创建静态内部类对象（不需要外部类实例）
Outer.StaticInner inner = new Outer.StaticInner();
inner.display();

// 调用静态内部类的静态方法
Outer.StaticInner.staticMethod();`
			},
			{
				point: '局部内部类定义在方法或代码块中，只能在定义的作用域内使用，可以访问final或等效final的局部变量。',
				code: `public class Outer {
    public void method() {
        final String finalVar = "final变量";
        String effectiveFinalVar = "等效final";
        
        // 局部内部类
        class LocalInner {
            public void display() {
                // 可以访问final或等效final的局部变量
                System.out.println(finalVar);
                System.out.println(effectiveFinalVar);
                
                // effectiveFinalVar = "修改";  // 这会导致编译错误
            }
        }
        
        // 只能在方法内使用
        LocalInner inner = new LocalInner();
        inner.display();
    }
    
    public void anotherMethod() {
        // LocalInner inner = new LocalInner();  // 错误！
    }
}`
			},
			{
				point: '匿名内部类没有类名，常用于实现接口或继承类的快速实现，特别适合一次性使用的场景。',
				code: `// 接口
public interface Greeting {
    void sayHello(String name);
}

public class AnonymousDemo {
    public void test() {
        // 匿名内部类实现接口
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello(String name) {
                System.out.println("Hello, " + name);
            }
        };
        greeting.sayHello("张三");
        
        // 匿名内部类继承抽象类
        abstract class Animal {
            abstract void makeSound();
        }
        
        Animal dog = new Animal() {
            @Override
            void makeSound() {
                System.out.println("汪汪");
            }
        };
        dog.makeSound();
        
        // 常用于事件监听
        button.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick() {
                System.out.println("按钮被点击");
            }
        });
    }
}`
			},
			{
				point: 'Lambda表达式（Java 8+）是匿名内部类的简化写法，用于函数式接口的实现。',
				code: `// 函数式接口（只有一个抽象方法）
@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

public class LambdaDemo {
    public void test() {
        // 传统匿名内部类
        Calculator add = new Calculator() {
            @Override
            public int calculate(int a, int b) {
                return a + b;
            }
        };
        
        // Lambda表达式（简化写法）
        Calculator subtract = (a, b) -> a - b;
        Calculator multiply = (a, b) -> {
            return a * b;
        };
        
        System.out.println(add.calculate(5, 3));        // 8
        System.out.println(subtract.calculate(5, 3));   // 2
        System.out.println(multiply.calculate(5, 3));   // 15
        
        // Lambda用于集合操作
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        names.forEach(name -> System.out.println(name));
    }
}`
			}
		]
	},
	{
		id: 10,
		title: '包与访问控制',
		description: '包用于组织类，访问修饰符控制类和成员的可见性，是Java封装性的重要体现。',
		icon: '📦',
		categoryId: 'oop',
		categoryName: '面向对象编程',
		categoryIcon: '🎯',
		difficulty: '重要',
		color: 'linear-gradient(135deg, #fa709a 0%, #fee140 100%)',
		headerBg: 'linear-gradient(135deg, #2c3e50 0%, #34495e 100%)',
		tagBg: 'linear-gradient(135deg, #e74c3c 0%, #c0392b 100%)',
		tagColor: '#ffffff',
		difficultyBg: 'linear-gradient(135deg, #f39c12 0%, #e67e22 100%)',
		keyPoints: [
			{
				point: '包用于组织类和接口，避免命名冲突，使用package关键字声明，通常采用域名反写。',
				code: `// 声明包（文件第一行）
package com.example.project.model;

// 导入其他包的类
import java.util.ArrayList;
import java.util.List;
import com.example.project.util.*;  // 导入包中所有类

public class User {
    private String name;
    private List<String> roles;
    
    public User(String name) {
        this.name = name;
        this.roles = new ArrayList<>();
    }
}

// 使用完全限定名（不导入）
java.util.Date date = new java.util.Date();
java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis());`
			},
			{
				point: 'Java有四种访问修饰符：public、protected、default（包私有）、private，控制不同范围的访问权限。',
				code: `package com.example;

public class AccessDemo {
    public int publicField = 1;           // 所有类可访问
    protected int protectedField = 2;     // 同包+子类可访问
    int defaultField = 3;                 // 同包可访问（默认）
    private int privateField = 4;         // 仅本类可访问
    
    public void publicMethod() { }        // 所有类可访问
    protected void protectedMethod() { }  // 同包+子类可访问
    void defaultMethod() { }              // 同包可访问
    private void privateMethod() { }      // 仅本类可访问
}

// 不同包的子类
package com.other;
import com.example.AccessDemo;

public class SubClass extends AccessDemo {
    public void test() {
        System.out.println(publicField);      // OK
        System.out.println(protectedField);   // OK（子类）
        // System.out.println(defaultField);  // 错误（不同包）
        // System.out.println(privateField);  // 错误（私有）
    }
}`
			},
			{
				point: '静态导入(static import)可以直接使用类的静态成员，简化代码，但要避免滥用导致可读性下降。',
				code: `// 导入静态成员
import static java.lang.Math.*;
import static java.lang.System.out;

public class StaticImportDemo {
    public void test() {
        // 不需要类名前缀
        double result1 = PI * 2;           // Math.PI
        double result2 = pow(2, 3);        // Math.pow
        double result3 = sqrt(16);         // Math.sqrt
        
        out.println(result1);              // System.out
        out.println(result2);
        out.println(result3);
    }
}

// 导入自定义类的静态成员
public class Constants {
    public static final String APP_NAME = "MyApp";
    public static final int VERSION = 1;
    
    public static void printInfo() {
        System.out.println(APP_NAME + " v" + VERSION);
    }
}

import static com.example.Constants.*;

public class Test {
    public void display() {
        System.out.println(APP_NAME);      // 直接使用
        printInfo();                        // 直接调用
    }
}`
			},
			{
				point: '合理使用访问控制实现封装：数据私有化、提供公共接口、隐藏实现细节、提高代码安全性。',
				code: `public class BankAccount {
    // 私有属性，隐藏实现细节
    private String accountNumber;
    private double balance;
    private List<Transaction> transactions;
    
    // 公共构造方法
    public BankAccount(String accountNumber) {
        this.accountNumber = accountNumber;
        this.balance = 0.0;
        this.transactions = new ArrayList<>();
    }
    
    // 公共接口，提供受控访问
    public boolean deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            logTransaction("存款", amount);
            return true;
        }
        return false;
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            logTransaction("取款", amount);
            return true;
        }
        return false;
    }
    
    // 只读访问
    public double getBalance() {
        return balance;
    }
    
    // 私有辅助方法，隐藏实现
    private void logTransaction(String type, double amount) {
        transactions.add(new Transaction(type, amount));
    }
    
    // 返回副本，防止外部修改
    public List<Transaction> getTransactions() {
        return new ArrayList<>(transactions);
    }
}`
			},
			{
				point: '类的访问修饰符只能是public或default（包私有），一个Java文件只能有一个public类，且类名与文件名一致。',
				code: `// 文件名：MyClass.java

// public类，可以被所有包访问
public class MyClass {
    public void publicMethod() {
        System.out.println("公共方法");
    }
}

// 包私有类（默认），只能被同包访问
class HelperClass {
    void helperMethod() {
        System.out.println("辅助方法");
    }
}

// 内部类可以使用所有修饰符
class OuterClass {
    public class PublicInner { }
    protected class ProtectedInner { }
    class DefaultInner { }
    private class PrivateInner { }
}

// 错误示例
// public class AnotherClass { }  // 错误：一个文件只能有一个public类
// protected class WrongClass { } // 错误：顶级类不能用protected
// private class WrongClass2 { }  // 错误：顶级类不能用private`
			}
		]
	}
];